import { ServerInfo } from '../types/Card';
import { DeviceEventEmitter } from 'react-native';

export class NetworkDiscoveryService {
  private static instance: NetworkDiscoveryService;
  private discoveredServers: ServerInfo[] = [];
  private currentServer: ServerInfo | null = null;
  private isListening = false;
  private discoveryTimeout: NodeJS.Timeout | null = null;

  private constructor() {
    // 监听 UDP 发现事件
    DeviceEventEmitter.addListener('onBabyTapMobileDiscovered', this.handleDeviceDiscovered);
  }

  public static getInstance(): NetworkDiscoveryService {
    if (!NetworkDiscoveryService.instance) {
      NetworkDiscoveryService.instance = new NetworkDiscoveryService();
    }
    return NetworkDiscoveryService.instance;
  }

  /**
   * 开始监听 UDP 广播（等待 BabyTapMobile 发送广播）
   */
  public async startUDPDiscovery(): Promise<void> {
    if (this.isListening) {
      console.log('🔍 UDP 监听已在进行中...');
      return;
    }

    this.isListening = true;
    console.log('🔍 开始监听 UDP 广播...');
    console.log('⏰ 等待 BabyTapMobile 发送广播（每30秒一次）...');

    // 设置超时时间（35秒，给 BabyTapMobile 足够时间发送广播）
    this.discoveryTimeout = setTimeout(() => {
      this.stopUDPDiscovery();
      console.log('⏰ UDP 监听超时，未发现 BabyTapMobile 设备');
    }, 35000);
  }

  /**
   * 停止 UDP 监听
   */
  public stopUDPDiscovery(): void {
    this.isListening = false;
    if (this.discoveryTimeout) {
      clearTimeout(this.discoveryTimeout);
      this.discoveryTimeout = null;
    }
    console.log('🔍 UDP 监听已停止');
  }

  /**
   * 处理设备发现事件
   */
  private handleDeviceDiscovered = (eventData: any) => {
    if (!this.isListening) return;

    console.log('📡 收到 BabyTapMobile 广播:', eventData);

    const serverInfo: ServerInfo = {
      ip: eventData.host,
      port: eventData.port,
      url: eventData.url,
      isHttps: eventData.isHttps,
    };

    // 检查是否已经存在相同的服务器
    const existingIndex = this.discoveredServers.findIndex(
      server => server.ip === serverInfo.ip && server.port === serverInfo.port
    );

    if (existingIndex >= 0) {
      // 更新现有服务器信息
      this.discoveredServers[existingIndex] = serverInfo;
    } else {
      // 添加新服务器
      this.discoveredServers.push(serverInfo);
    }

    console.log(`✅ 发现 BabyTapMobile 服务器: ${serverInfo.ip}:${serverInfo.port}`);
    
    // 停止监听，因为已经发现了服务器
    this.stopUDPDiscovery();
  };

  /**
   * 扫描网络（兼容旧接口，实际使用 UDP 监听）
   */
  public async scanNetwork(): Promise<ServerInfo[]> {
    console.log('🔍 开始 UDP 发现模式...');
    
    // 清除之前的发现
    this.discoveredServers = [];
    
    // 开始 UDP 监听
    await this.startUDPDiscovery();
    
    // 等待发现结果
    return new Promise((resolve) => {
      const checkInterval = setInterval(() => {
        if (!this.isListening || this.discoveredServers.length > 0) {
          clearInterval(checkInterval);
          resolve([...this.discoveredServers]);
        }
      }, 1000);
    });
  }

  /**
   * 获取发现的服务器列表
   */
  public getDiscoveredServers(): ServerInfo[] {
    return [...this.discoveredServers];
  }

  /**
   * 设置当前使用的服务器
   */
  public setCurrentServer(server: ServerInfo): void {
    this.currentServer = server;
    console.log('✅ 设置当前服务器:', server);
  }

  /**
   * 获取当前服务器
   */
  public getCurrentServer(): ServerInfo | null {
    return this.currentServer;
  }

  /**
   * 自动选择最佳服务器
   */
  public autoSelectServer(): ServerInfo | null {
    if (this.discoveredServers.length === 0) {
      return null;
    }

    // 优先选择 HTTPS 服务器
    const httpsServers = this.discoveredServers.filter(s => s.isHttps);
    if (httpsServers.length > 0) {
      this.currentServer = httpsServers[0];
      return this.currentServer;
    }

    // 如果没有 HTTPS，选择第一个 HTTP 服务器
    this.currentServer = this.discoveredServers[0];
    return this.currentServer;
  }

  /**
   * 清除发现的服务器列表
   */
  public clearDiscoveredServers(): void {
    this.discoveredServers = [];
    this.currentServer = null;
  }
}

export default NetworkDiscoveryService.getInstance(); 